package bigmath;

import java.util.EmptyStackException;
import java.util.Objects;

public class StackDemo2 {

    public static void main(String[] args) {

        ArrayStack<String> stack = new ArrayStack<>();
        stack.push("a");
        stack.push("b");
        stack.push("d");
        stack.push("c");
        stack.push("e");
        System.out.println(stack.pop());
        System.out.println(stack.search("d"));
        System.out.println(stack);
        System.out.println(stack.pop());
        System.out.println(stack);
    }

}
//class ArrayStack<E> {
//    private Object[] arr = new Object[arr.length*2];
//}


// 顺序栈
class ArrayStack<E> {

    // 构建数组来存储元素
    private Object[] arr = new Object[10];
    // 定义变量来记录元素个数
    private int size = 0;

    // 添加元素
    public void push(E e) {
        // 判断是否需要扩容
        if (size >= arr.length) {
            // 定义新数组
            Object[] newArr = new Object[arr.length * 2];
            // 将原数组中的元素拷贝到新数组中
            System.arraycopy(arr, 0, newArr, 0, size);
            arr = newArr;
        }
        // 添加元素，元素个数+1
        arr[size++] = e;
    }


//    public E peak(){
//        if (size<=0){
//            throw new EmptyStackException();
//            return (E)arr[size-1];
//        }
//    }

    //获取并移除栈顶元素
//    public E pop(){
//        E e = peek();
//        arr[size--] == null;
//        return e;
//    }


    //  获取但是不移除栈顶元素
    public E peek() {
        // 判断是否为空栈
        if (size <= 0)
            throw new EmptyStackException();
        return (E) arr[size - 1];
    }

     //获取并且移除栈顶元素
    public E pop() {
        // 获取栈顶元素
        E e = peek();
        // 移除掉这个元素，元素个数-1
        arr[size--] = null;
        return e;
    }

    // 判断栈是否为空
    public boolean empty() {
        return size <= 0;
    }

    // 从栈顶到栈底来查找指定元素第一次出现的位置
    public int search(E e) {
        for (int i = size - 1, j = 1; i >= 0; i--, j++) {
            if (Objects.equals(arr[i], e))
                return j;
        }
        return -1;
    }

    @Override
    public boolean equals(Object o) {
        // 地址
        if (this == o) return true;
        // 参数为空
        if (o == null) return false;
        // 类型
        if (this.getClass() != o.getClass()) return false;
        // 强转
        ArrayStack<E> s = (ArrayStack<E>) o;
        // 元素个数
        if (this.size != s.size) return false;
        // 元素
        for (int i = 0; i < size; i++) {
            if (!Objects.equals(this.arr[i], s.arr[i])) return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int h = 0;
        for (int i = size - 1; i >= 0; i--) {
            h = 31 * h + (arr[i] == null ? 0 : arr[i].hashCode());
        }
        return h;
    }

    @Override
    public String toString() {
        // 判断是否是一个空栈
        if (size <= 0) return "[]";
        // 拼接元素
        StringBuilder sb = new StringBuilder("[");
        for (int i = size - 1; i >= 0; i--) {
            sb.append(arr[i]).append(", ");
        }
        // 转化为字符串，去掉尾部的", "
        String str = sb.toString();
        str = str.substring(0, str.length() - 2);
        // 返回
        return str += "]";
    }
}
